I don't think this change is needed or even makes sense. I would not modify New as part of this PR.

Yes, worked on it.

this field is not used, please remove

this field is not used, please remove

this doesn't make sense IMO. Just because a timestamp is added by Create in this case doesn't mean that assert.NotEqual is the right thing to check. Especially when you have a field called tt.expectedObj, which implies that you are expecting the function to return a specific object.

usually the best way to deal with this is to add a clock.Clock (https://pkg.go.dev/k8s.io/utils/clock#Clock) to the object being tested (in this case, to the REST object). In the "normal" case, the clock is set to RealClock, but for tests you can set it to FakeClock. This way you can freeze time and predict what the timestamp will be / should be in the returned object. There are multiple examples in the Antrea code base, so you can look for them.

nit: I would use the *statsv1alpha1.NodeLatencyStats type for this as well

the name is a bit confusion IMO. timeAdded to me means that the time is added by the Create function, but that's not how you use it. I would suggest something less ambiguous, such as timestampMissing.

rename to creationTimestamp

same comment for subsequent tests

testing2 is not a good name for an import, use clocktesting

it's better to have a separate clock instance for each test IMO, as some tests may modify the clock

this is not ok. You should not modify the test logic based on the test case name, otherwise it defeats the purpose of having table-driven tests. You need to use expectedObj which you are ignoring at the moment.

don't remove the trailing newline character

this has not been addressed yet

Given that the clock is only necessary for testing, let's use the following approach instead:

func NewREST() *REST {
	return newRESTWithClock(cloc.RealClock{})
}

func newRESTWithClock(clock clock.Clock) *REST {
	return &REST{
		indexer: cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}),
		clock:   clock,
	}
}

This way in apiserver.go you can keep calling NewREST() (no clock argument required) and in tests you can call newRESTWithClock.

This is not good because your test case assumes that it will run second and that the clock will have been advanced twice as a result. A key principle of table-driven test cases is that test cases should not depend on each other. They should be runnable individually, independently, in any order, and sometimes even in parallel.

The test should be like this:

func TestRESTCreate(t *testing.T) {
        ctx := context.Background()
        now := time.Now()
        const timeStep = 1*time.Minute
	tests := []struct {
		name        string
		summary     *statsv1alpha1.NodeLatencyStats
		expectedObj *statsv1alpha1.NodeLatencyStats
	}{
		{
			name: "create with existing timestamp",
			summary: &statsv1alpha1.NodeLatencyStats{
				ObjectMeta:           metav1.ObjectMeta{Name: "node1", CreationTimestamp: metav1.Time{Time: now}},
				PeerNodeLatencyStats: nil,
			},
			expectedObj: &statsv1alpha1.NodeLatencyStats{
				ObjectMeta:           metav1.ObjectMeta{Name: "node1", CreationTimestamp: metav1.Time{Time: now}},
				PeerNodeLatencyStats: nil,
			},
		},
		{
			name: "create with no existing timestamp",
			summary: &statsv1alpha1.NodeLatencyStats{
				ObjectMeta:           metav1.ObjectMeta{Name: "node1"},
				PeerNodeLatencyStats: nil,
			},
			expectedObj: &statsv1alpha1.NodeLatencyStats{
				// the test case advances the clock by timeStep
				ObjectMeta:           metav1.ObjectMeta{Name: "node1", CreationTimestamp: metav1.Time{Time: now.Add(timeStep)}},
				PeerNodeLatencyStats: nil,
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
	                 fakeClock := clocktesting.NewFakeClock(now)
			r := newRESTWithClock(fakeClock)
			fakeClock.SetTime(now.Add(timeStep))
			obj, err := r.Create(ctx, tt.summary, nil, nil)
			require.NoError(t, err)
			assert.Equal(t, tt.expectedObj, obj)
		})
	}
}

you can use the code as is. I also updated the test case names for more clarity.

this has not been addressed yet

I don't think this test needs a fake clock, so you can remove it

follow the example I gave above: now := time.Now()

then in each subtest, create a separate clock with fakeClock := clocktesting.NewFakeClock(now)

follow the example I gave above: now := time.Now()

then in each subtest, create a separate clock with fakeClock := clocktesting.NewFakeClock(now)

I may have forgotten to suggest it in my previous review

remove this extra line

nit: introduce now := time.Now() for consistency with other tests and less verbosity